/**
 * Copyright &copy; 2012-2016 <a href="https://github.com/thinkgem/jeesite">JeeSite</a> All rights reserved.
 */
package com.thinkgem.jeesite.modules.sys.service;

import java.text.SimpleDateFormat;
import java.util.*;

import com.google.common.base.Function;
import com.google.common.collect.Maps;
import com.thinkgem.jeesite.common.utils.SynchroDataUtils;
import com.thinkgem.jeesite.modules.sys.utils.ChineseToEnglish;
import com.thinkgem.jeesite.modules.sys.utils.DictUtils;
import com.thinkgem.jeesite.modules.tgb.SpringActivemq.dao.AmqMsgDao;
import com.thinkgem.jeesite.modules.tgb.SpringActivemq.entity.MSG;
import com.thinkgem.jeesite.modules.tgb.SpringActivemq.mq.producer.topic.TopicSender;
import com.thinkgem.jeesite.modules.tgb.SpringActivemq.service.MyAmqService;
import net.sf.ezmorph.object.DateMorpher;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.util.JSONUtils;
import org.activiti.engine.IdentityService;
import org.activiti.engine.identity.Group;
import org.apache.shiro.session.Session;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.thinkgem.jeesite.common.config.Global;
import com.thinkgem.jeesite.common.persistence.Page;
import com.thinkgem.jeesite.common.security.Digests;
import com.thinkgem.jeesite.common.security.shiro.session.SessionDAO;
import com.thinkgem.jeesite.common.service.BaseService;
import com.thinkgem.jeesite.common.service.ServiceException;
import com.thinkgem.jeesite.common.utils.CacheUtils;
import com.thinkgem.jeesite.common.utils.Encodes;
import com.thinkgem.jeesite.common.utils.StringUtils;
import com.thinkgem.jeesite.common.web.Servlets;
import com.thinkgem.jeesite.modules.sys.dao.MenuDao;
import com.thinkgem.jeesite.modules.sys.dao.RoleDao;
import com.thinkgem.jeesite.modules.sys.dao.UserDao;
import com.thinkgem.jeesite.modules.sys.entity.Menu;
import com.thinkgem.jeesite.modules.sys.entity.Office;
import com.thinkgem.jeesite.modules.sys.entity.Role;
import com.thinkgem.jeesite.modules.sys.entity.User;
import com.thinkgem.jeesite.modules.sys.security.SystemAuthorizingRealm;
import com.thinkgem.jeesite.modules.sys.utils.LogUtils;
import com.thinkgem.jeesite.modules.sys.utils.UserUtils;

import javax.annotation.Resource;
import javax.jms.JMSException;

/**
 * 系统管理，安全相关实体的管理类,包括用户、角色、菜单.
 *
 * @author ThinkGem
 * @version 2013-12-05
 */
@Service
@Transactional(readOnly = true)
public class SystemService extends BaseService implements InitializingBean {

    public static final String HASH_ALGORITHM = "SHA-1";
    public static final int HASH_INTERATIONS = 1024;
    public static final int SALT_SIZE = 8;

    @Autowired
    private UserDao userDao;
    @Autowired
    private RoleDao roleDao;
    @Autowired
    private MenuDao menuDao;
    @Autowired
    private SessionDAO sessionDao;
    @Autowired
    private SystemAuthorizingRealm systemRealm;

    public SessionDAO getSessionDao() {
        return sessionDao;
    }

    @Autowired
    private IdentityService identityService;

    @Resource
    TopicSender topicSender;

    @Autowired
    private AmqMsgDao amqMsgDao;

    //-- User Service --//

    /**
     * 获取用户
     *
     * @param id
     * @return
     */
    public User getUser(String id) {
        return UserUtils.get(id);
    }

    /**
     * 根据登录名获取用户
     *
     * @param loginName
     * @return
     */
    public User getUserByLoginName(String loginName) {
        return UserUtils.getByLoginName(loginName);
    }

    public Page<User> findUser(Page<User> page, User user) {
        // 生成数据权限过滤条件（dsf为dataScopeFilter的简写，在xml中使用 ${sqlMap.dsf}调用权限SQL）
        user.getSqlMap().put("dsf", dataScopeFilter(user.getCurrentUser(), "o", "a"));
        // 设置分页参数
        user.setPage(page);
        // 执行分页查询
        List<User> users = userDao.findList(user);
        UserUtils.getOtherInfoForList(users, false);
        page.setList(users);
        return page;
    }

    /**
     * 无分页查询人员列表
     *
     * @param user
     * @return
     */
    public List<User> findUser(User user) {
        // 生成数据权限过滤条件（dsf为dataScopeFilter的简写，在xml中使用 ${sqlMap.dsf}调用权限SQL）
        user.getSqlMap().put("dsf", dataScopeFilter(user.getCurrentUser(), "o", "a"));
        List<User> list = userDao.findList(user);
        UserUtils.getOtherInfoForList(list, false);
        return list;
    }


    public Page<User> findPage(Page<User> page, User user) {
        // 设置分页参数
        user.setPage(page);
        // 执行分页查询
        List<User> users = userDao.findList(user);
        UserUtils.getOtherInfoForList(users, false);
        page.setList(users);
        return page;
    }

    public User getByName(User user) {

        return userDao.getByName(user);
    }

    /**
     * 通过部门ID获取用户列表，仅返回用户id和name（树查询用户时用）
     *
     * @param
     * @return
     */
    @SuppressWarnings("unchecked")
    public List<User> findUserByOfficeId(String officeId) {
        List<User> list = (List<User>) CacheUtils.get(UserUtils.USER_CACHE, UserUtils.USER_CACHE_LIST_BY_OFFICE_ID_ + officeId);
        if (list == null) {
            User user = new User();
            user.setOffice(new Office(officeId));
            list = userDao.findUserByOfficeId(user);
            CacheUtils.put(UserUtils.USER_CACHE, UserUtils.USER_CACHE_LIST_BY_OFFICE_ID_ + officeId, list);
        }
        return list;
    }


    /**
     * 通过公司ID获取用户列表，仅返回用户id和name（树查询用户时用）
     *
     * @param
     * @return
     */
    @SuppressWarnings("unchecked")
    public List<User> findUserByCompanyId(String companyId) {

        if (companyId != null) {

            String delFlag = "0";
            List<User> list = userDao.findUserByCompanyId(companyId, delFlag);
            return list;
        }
        return null;
    }


    /**
     * 通过部门ID获取角色列表，仅返回角色id和name（树查询角色时用）
     *
     * @param
     * @return
     */
    @SuppressWarnings("unchecked")
    public List<Role> findRoleByOfficeId(String officeId) {
        List<Role> list = (List<Role>) CacheUtils.get(UserUtils.CACHE_ROLE_LIST, UserUtils.USER_CACHE_LIST_BY_OFFICE_ID_ + officeId);
        if (list == null) {
            Role role = new Role();
            role.setOffice(new Office(officeId));
            list = roleDao.findRoleByOfficeId(role);
            CacheUtils.put(UserUtils.CACHE_ROLE_LIST, UserUtils.USER_CACHE_LIST_BY_OFFICE_ID_ + officeId, list);
        }
        return list;
    }

    @Transactional(readOnly = false)
    public void saveUser(User user) {
        if (StringUtils.isBlank(user.getId())) {
            user.preInsert();
            userDao.insert(user);
        } else {
            // 清除原用户机构用户缓存
            User oldUser = userDao.get(user.getId());
            if (oldUser.getOffice() != null && oldUser.getOffice().getId() != null) {
                CacheUtils.remove(UserUtils.USER_CACHE, UserUtils.USER_CACHE_LIST_BY_OFFICE_ID_ + oldUser.getOffice().getId());
            }
            // 更新用户数据
            user.preUpdate();
            userDao.update(user);
        }
        if (StringUtils.isNotBlank(user.getId())) {
            // 更新用户与角色关联
            userDao.deleteUserRole(user);
            if (user.getRoleList() != null && user.getRoleList().size() > 0) {
                userDao.insertUserRole(user);
            } else {
                throw new ServiceException(user.getLoginName() + "没有设置角色！");
            }
            // 将当前用户同步到Activiti
            saveActivitiUser(user);
            // 清除用户缓存
            UserUtils.clearCache(user);
//			// 清除权限缓存
//			systemRealm.clearAllCachedAuthorizationInfo();
        }
    }

    /**
     * OA同步人力资源的人员数据，并将数据
     *
     * @param user
     */
    @Transactional(readOnly = false)
    public void savePeople(User user) {

        // 根据姓名来查询用户
        List<User> user1 = userDao.findUserByName(user);
        System.out.println(user1);
        if (user1 != null && user1.size() > 0 && user1.size() != 0) {
            //将从人力资源处拿到的数据,与OA中原有的数据进行对比,如果有相同的则进行修改,否则进行增加
            for (int i = 0; i < user1.size(); i++) {
                System.out.println(user1.size());
                if (user1.size() == 1) {
                    deal(user1.get(i), user).preUpdate();
                    userDao.update(deal(user1.get(i), user));
                } else {
                    //根据姓名和身份证号来查询用户
//                    if(StringUtils.equalsIgnoreCase("王静",user.getName())){
                    User user2 = userDao.findByName(user);
                    if (user2 != null) {
                        deal(user2, user).preUpdate();
                        userDao.update(deal(user2, user));
                    }
                }
            }
        } else {
            user.preInsert();
            userDao.insert(user);
        }
    }


    /**
     * 处理传递的数据
     *
     * @param user   从OA数据库中查询的数据
     * @param rlUser 从人力资源处接收的数据
     * @return
     */
    private User deal(User user, User rlUser) {
        if (rlUser.getOffice() != null) {
            user.setOffice(rlUser.getOffice());
        }
        if (rlUser.getCompany() != null) {
            user.setCompany(rlUser.getCompany());
        }
        if (rlUser.getName() != null && rlUser.getName() != "") {
            user.setName(rlUser.getName());
        }
        if (rlUser.getCardNo() != null && rlUser.getCardNo() != "") {
            user.setCardNo(rlUser.getCardNo());
        }
        if (rlUser.getPhone() != null && rlUser.getPhone() != "") {
            user.setPhone(rlUser.getPhone());
        }
        if (rlUser.getEmail() != null && rlUser.getEmail() != "") {
            user.setEmail(rlUser.getEmail());
        }
        return user;
    }

    @Transactional(readOnly = false)
    public void updateUserInfo(User user) {
        user.preUpdate();
        userDao.updateUserInfo(user);
        // 清除用户缓存
        UserUtils.clearCache(user);

//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
    }

    /**
     * 将OA修改的用户同步到其他系统中
     * @param user
     * @return
     */
    public JSONObject addUserJsonValue(User user){
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("id", user.getId());
        jsonObject.put("name", user.getName());
        jsonObject.put("cardNo", user.getCardNo());
        jsonObject.put("orgId", user.getCompany().getId());
        jsonObject.put("deptId", user.getOffice().getId());
        jsonObject.put("phoneNo", user.getPhone());
//        jsonObject.put("email", user.getEmail());
        jsonObject.put("updateBy", user.getId());
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String updateString = formatter.format(user.getUpdateDate());
        jsonObject.put("updateDate",updateString);
        return jsonObject;
    }

    /**
     * 将OA修改的用户同步到其他系统中
     * @param user
     * @return
     */
    public JSONObject addPwdJsonValue(User user){
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("id", user.getId());
        jsonObject.put("password", user.getPassword());
        return jsonObject;
    }


    @Transactional(readOnly = false)
    public void deleteUser(User user) {
        userDao.delete(user);
        // 同步到Activiti
        deleteActivitiUser(user);
        // 清除用户缓存
        UserUtils.clearCache(user);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
    }

    @Transactional(readOnly = false)
    public void updatePasswordById(String id, String loginName, String newPassword) {
        User user = new User(id);
        user.setPassword(entryptPassword(newPassword));
        userDao.updatePasswordById(user);
        // 清除用户缓存
        user.setLoginName(loginName);
        UserUtils.clearCache(user);


        //修改后的用户同步到其他系统中
        try {
            JSONArray jsonArray = new JSONArray();
            JSONObject jsonObject=addPwdJsonValue(user);
            jsonArray.add(jsonObject);
            String msgId = UUID.randomUUID().toString();
            String json = jsonArray.toString();
            topicSender.send("pwd_synchronize ", json, msgId, "updatePwd");

        } catch (JMSException e) {
            e.printStackTrace();
        }



//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
    }

    @Transactional(readOnly = false)
    public void updateUserLoginInfo(User user) {
        // 保存上次登录信息
        user.setOldLoginIp(user.getLoginIp());
        user.setOldLoginDate(user.getLoginDate());
        // 更新本次登录信息
        user.setLoginIp(StringUtils.getRemoteAddr(Servlets.getRequest()));
        user.setLoginDate(new Date());
        userDao.updateLoginInfo(user);
    }

    /**
     * 生成安全的密码，生成随机的16位salt并经过1024次 sha-1 hash
     */
    public static String entryptPassword(String plainPassword) {
        String plain = Encodes.unescapeHtml(plainPassword);
        byte[] salt = Digests.generateSalt(SALT_SIZE);
        byte[] hashPassword = Digests.sha1(plain.getBytes(), salt, HASH_INTERATIONS);
        return Encodes.encodeHex(salt) + Encodes.encodeHex(hashPassword);
    }

    /**
     * 验证密码
     *
     * @param plainPassword 明文密码
     * @param password      密文密码
     * @return 验证成功返回true
     */
    public static boolean validatePassword(String plainPassword, String password) {
        String plain = Encodes.unescapeHtml(plainPassword);
        byte[] salt = Encodes.decodeHex(password.substring(0, 16));
        byte[] hashPassword = Digests.sha1(plain.getBytes(), salt, HASH_INTERATIONS);
        return password.equals(Encodes.encodeHex(salt) + Encodes.encodeHex(hashPassword));
    }

    /**
     * 获得活动会话
     *
     * @return
     */
    public Collection<Session> getActiveSessions() {
        return sessionDao.getActiveSessions(false);
    }

    //-- Role Service --//

    public Role getRole(String id) {
        return roleDao.get(id);
    }

    public Role getRoleByName(String name) {
        Role r = new Role();
        r.setName(name);
        return roleDao.getByName(r);
    }

    public Role getRoleByEnname(String enname) {
        Role r = new Role();
        r.setEnname(enname);
        return roleDao.getByEnname(r);
    }

    public List<Role> findRole(Role role) {
        return roleDao.findList(role);
    }

    public List<Role> findAllRole() {
        return UserUtils.getRoleList();
    }

    /**
     * 根据userId查询角色信息
     * @param userId
     * @return
     */
    public List<Role> getRoleByUserId(String userId){
      return roleDao.getRoleByUserId(userId);
    }

    @Transactional(readOnly = false)
    public void saveRole(Role role) {
        if (StringUtils.isBlank(role.getId())) {
            role.preInsert();
            roleDao.insert(role);
            // 同步到Activiti
            saveActivitiGroup(role);
        } else {
            role.preUpdate();
            roleDao.update(role);
        }
        // 更新角色与菜单关联
        roleDao.deleteRoleMenu(role);
        if (role.getMenuList().size() > 0) {
            roleDao.insertRoleMenu(role);
        }
        // 更新角色与部门关联
        roleDao.deleteRoleOffice(role);
        if (role.getOfficeList().size() > 0) {
            roleDao.insertRoleOffice(role);
        }
        // 同步到Activiti
        saveActivitiGroup(role);
        // 清除用户角色缓存
        UserUtils.removeCache(UserUtils.CACHE_ROLE_LIST);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
    }

    @Transactional(readOnly = false)
    public void deleteRole(Role role) {
        roleDao.delete(role);
        // 同步到Activiti
        deleteActivitiGroup(role);
        // 清除用户角色缓存
        UserUtils.removeCache(UserUtils.CACHE_ROLE_LIST);
    }

    @Transactional(readOnly = false)
    public Boolean outUserInRole(Role role, User user) {
        List<Role> roles = user.getRoleList();
        for (Role e : roles) {
            if (e.getId().equals(role.getId())) {
                roles.remove(e);
                saveUser(user);
                return true;
            }
        }
        return false;
    }

    @Transactional(readOnly = false)
    public User assignUserToRole(Role role, User user) {
        if (user == null) {
            return null;
        }
        List<String> roleIds = user.getRoleIdList();
        if (roleIds.contains(role.getId())) {
            return null;
        }
        user.getRoleList().add(role);
        saveUser(user);
        return user;
    }

    //-- Menu Service --//

    public Menu getMenu(String id) {
        return menuDao.get(id);
    }

    public List<Menu> findAllMenu() {
        return UserUtils.getMenuList();
    }

    @Transactional(readOnly = false)
    public void saveMenu(Menu menu) {

        // 获取父节点实体
        menu.setParent(this.getMenu(menu.getParent().getId()));

        // 获取修改前的parentIds，用于更新子节点的parentIds
        String oldParentIds = menu.getParentIds();

        // 设置新的父节点串
        menu.setParentIds(menu.getParent().getParentIds() + menu.getParent().getId() + ",");

        // 保存或更新实体
        if (StringUtils.isBlank(menu.getId())) {
            User user = UserUtils.getUser();
            Role role = roleDao.getByUserId(user.getId());
            menu.preInsert();
            if (!UserUtils.getUser().isAdmin()) {
                String menuId = menu.getId();
                int i = menuDao.insert(menu);
                if (i > 0) {
                    Menu menu1 = new Menu();
                    menu1.setRoleId(role.getRoleId());
                    menu1.setMenuId(menuId);
                    menuDao.insertRoleMenu(menu1);
                }

            } else {
                menuDao.insert(menu);
            }

        } else {
            menu.preUpdate();
            menuDao.update(menu);
        }

        // 更新子节点 parentIds
        Menu m = new Menu();
        m.setParentIds("%," + menu.getId() + ",%");
        List<Menu> list = menuDao.findByParentIdsLike(m);
        for (Menu e : list) {
            e.setParentIds(e.getParentIds().replace(oldParentIds, menu.getParentIds()));
            menuDao.updateParentIds(e);
        }
        // 清除用户菜单缓存
        UserUtils.removeCache(UserUtils.CACHE_MENU_LIST);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
        // 清除日志相关缓存
        CacheUtils.remove(LogUtils.CACHE_MENU_NAME_PATH_MAP);
    }

    @Transactional(readOnly = false)
    public void updateMenuSort(Menu menu) {
        menuDao.updateSort(menu);
        // 清除用户菜单缓存
        UserUtils.removeCache(UserUtils.CACHE_MENU_LIST);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
        // 清除日志相关缓存
        CacheUtils.remove(LogUtils.CACHE_MENU_NAME_PATH_MAP);
    }

    @Transactional(readOnly = false)
    public void deleteMenu(Menu menu) {
        menuDao.delete(menu);
        // 清除用户菜单缓存
        UserUtils.removeCache(UserUtils.CACHE_MENU_LIST);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
        // 清除日志相关缓存
        CacheUtils.remove(LogUtils.CACHE_MENU_NAME_PATH_MAP);
    }

    /**
     * 获取Key加载信息
     */
    public static boolean printKeyLoadMessage() {
        StringBuilder sb = new StringBuilder();
        sb.append("\r\n======================================================================\r\n");
        sb.append("\r\n                   欢迎使用 " + Global.getConfig("productName") + "\r\n");
        sb.append("\r\n======================================================================\r\n");
        System.out.println(sb.toString());
        return true;
    }

    ///////////////// Synchronized to the Activiti //////////////////

    // 已废弃，同步见：ActGroupEntityServiceFactory.java、ActUserEntityServiceFactory.java

    /**
     * 是需要同步Activiti数据，如果从未同步过，则同步数据。
     */
    private static boolean isSynActivitiIndetity = true;

    public void afterPropertiesSet() throws Exception {
        if (!Global.isSynActivitiIndetity()) {
            return;
        }
        if (isSynActivitiIndetity) {
            isSynActivitiIndetity = false;
            // 同步角色数据
            List<Group> groupList = identityService.createGroupQuery().list();
            if (groupList.size() == 0) {
                Iterator<Role> roles = roleDao.findAllList(new Role()).iterator();
                while (roles.hasNext()) {
                    Role role = roles.next();
                    saveActivitiGroup(role);
                }
            }
            // 同步用户数据
            List<org.activiti.engine.identity.User> userList = identityService.createUserQuery().list();
            if (userList.size() == 0) {
                Iterator<User> users = userDao.findAllList(new User()).iterator();
                while (users.hasNext()) {
                    saveActivitiUser(users.next());
                }
            }
        }
    }

    private void saveActivitiGroup(Role role) {
        if (!Global.isSynActivitiIndetity()) {
            return;
        }
        String groupId = role.getEnname();

        // 如果修改了英文名，则删除原Activiti角色
        if (StringUtils.isNotBlank(role.getOldEnname()) && !role.getOldEnname().equals(role.getEnname())) {
            identityService.deleteGroup(role.getOldEnname());
        }

        Group group = identityService.createGroupQuery().groupId(groupId).singleResult();
        if (group == null) {
            group = identityService.newGroup(groupId);
        }
        group.setName(role.getName());
        group.setType(role.getRoleType());
        identityService.saveGroup(group);

        // 删除用户与用户组关系
        List<org.activiti.engine.identity.User> activitiUserList = identityService.createUserQuery().memberOfGroup(groupId).list();
        for (org.activiti.engine.identity.User activitiUser : activitiUserList) {
            identityService.deleteMembership(activitiUser.getId(), groupId);
        }

        // 创建用户与用户组关系
        List<User> userList = findUser(new User(new Role(role.getId())));
        for (User e : userList) {
            String userId = e.getLoginName();//ObjectUtils.toString(user.getId());
            // 如果该用户不存在，则创建一个
            org.activiti.engine.identity.User activitiUser = identityService.createUserQuery().userId(userId).singleResult();
            if (activitiUser == null) {
                activitiUser = identityService.newUser(userId);
                activitiUser.setFirstName(e.getName());
                activitiUser.setLastName(StringUtils.EMPTY);
                activitiUser.setEmail(e.getEmail());
                activitiUser.setPassword(StringUtils.EMPTY);
                identityService.saveUser(activitiUser);
            }
            identityService.createMembership(userId, groupId);
        }
    }

    public void deleteActivitiGroup(Role role) {
        if (!Global.isSynActivitiIndetity()) {
            return;
        }
        if (role != null) {
            String groupId = role.getEnname();
            identityService.deleteGroup(groupId);
        }
    }

    private void saveActivitiUser(User user) {
        if (!Global.isSynActivitiIndetity()) {
            return;
        }
        String userId = user.getLoginName();//ObjectUtils.toString(user.getId());
        org.activiti.engine.identity.User activitiUser = identityService.createUserQuery().userId(userId).singleResult();
        if (activitiUser == null) {
            activitiUser = identityService.newUser(userId);
        }
        activitiUser.setFirstName(user.getName());
        activitiUser.setLastName(StringUtils.EMPTY);
        activitiUser.setEmail(user.getEmail());
        activitiUser.setPassword(StringUtils.EMPTY);
        identityService.saveUser(activitiUser);

        // 删除用户与用户组关系
        List<Group> activitiGroups = identityService.createGroupQuery().groupMember(userId).list();
        for (Group group : activitiGroups) {
            identityService.deleteMembership(userId, group.getId());
        }
        // 创建用户与用户组关系
        for (Role role : user.getRoleList()) {
            String groupId = role.getEnname();
            // 如果该用户组不存在，则创建一个
            Group group = identityService.createGroupQuery().groupId(groupId).singleResult();
            if (group == null) {
                group = identityService.newGroup(groupId);
                group.setName(role.getName());
                group.setType(role.getRoleType());
                identityService.saveGroup(group);
            }
            identityService.createMembership(userId, role.getEnname());
        }
    }

    private void deleteActivitiUser(User user) {
        if (!Global.isSynActivitiIndetity()) {
            return;
        }
        if (user != null) {
            String userId = user.getLoginName();//ObjectUtils.toString(user.getId());
            identityService.deleteUser(userId);
        }
    }

    ///////////////// Synchronized to the Activiti end //////////////////

    public Menu selectMenuByName(String name) {
        Menu menu = menuDao.selectMenuByName(name);
        return menu;
    }


    /**
     * OA同步人力资源的数据时，根据传递的身份证号查询用户的id
     *
     * @param user
     * @return
     */
   /* public User findCardNoUser(User user) {
        return userDao.findByName(user);
    }*/


    /**
     * OA同步人力资源的角色数据时，展示时根据部门来查看角色
     *
     * @param role
     * @return
     */
  /*  public List<Role> findRoleByDept(Role role) {
        return roleDao.findRoleByDept(role);
    }*/


    /**
     * OA同步人力资源角色数据，包括原有数据同步和AMQ新增数据同步
     *
     * @param type      判断是新增、修改或者删除操作
     * @param inputLine 人力资源传递的json字符串
     * @return
     * @author yangruidong
     */
   /* @Transactional(readOnly = false)
    public String saveRole(String type, String inputLine) {
        inputLine = inputLine.replaceAll("sort", "enname");
        //将json字符串转换成json数组后，直接将json数组转换成java对象的list集合，之后遍历集合保存到数据库中
        //处理转换JSON中日期到JAVA Date类型的处理方式
        JSONUtils.getMorpherRegistry().registerMorpher(new DateMorpher(new String[]{"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss"}));
        JSONArray jArray = JSONArray.fromObject(inputLine);
        List<Role> list1 = (List<Role>) JSONArray.toCollection(jArray, Role.class);
        for (int i = 0; i < list1.size(); i++) {
            Role a = list1.get(i);
            Office office = new Office();
            //设置归属的机构
            office.setId(a.getDeptId());
            a.setOffice(office);
            //设置OA中角色特有的数据
            //设置是否是系统数据
            a.setSysData("0");
            a.setRemarks(a.getEnname());
            //设置是否可用
            a.setUseable("1");
            //设置数据范围，默认是设置的所在公司的数据   为3
            a.setDataScope("3");
            //设置任务分配
            a.setEnname(null);
            a.setRoleType("assignment");
            a = dealWithUser(a);
            if (StringUtils.equalsIgnoreCase("add", type)) {
                //OA同步人力资源数据包括（AMQ新增和webService原有数据）
                saveRoleHrm(a);
            } else if (StringUtils.equalsIgnoreCase("update", type)) {
                System.out.println(a);
                Role of = roleDao.get(a.getId());
                    *//*of.preUpdate();
                    dao.update(of);*//*
            } else if (StringUtils.equalsIgnoreCase("delete", type)) {
                roleDao.delete(a);
            }

        }
        return "success";
    }*/


    /**
     * OA同步人力资源的角色数据
     * 包括角色与部门的对应表
     *
     * @param role
     */
 /*   @Transactional(readOnly = false)
    public void saveRoleHrm(Role role) {
        roleDao.insert(role);
        // 更新角色与部门关联
        roleDao.deleteRoleOffice(role);
        if (role.getOfficeList().size() > 0) {
            roleDao.insertRoleOffice(role);
        }
    }*/


    /**
     * OA同步人力资源的人员数据
     *
     * @param type
     */
    @Transactional(readOnly = false)
    public String savePeople(String type, String inputLine, String orgId) {
        List<Map<String, Object>> result;
        if(StringUtils.equalsIgnoreCase("1",UserUtils.getUser().getId())){
            orgId = "";
        }
        if (StringUtils.isBlank(inputLine)) {
            String urlIP = DictUtils.getDValue("oa_hrm_ip", "");
            String urlString = DictUtils.getDValue("oa_people_data", "");
            String url = urlIP + urlString;
            if (StringUtils.isNotBlank(orgId)) {
                url = url + "?orgId=" + orgId;
            }
            result = convertList(SynchroDataUtils.getJsonByUrl(url));
        } else {
            result = convertList(inputLine);
        }

        //修改用户密码：单独处理
        if(StringUtils.isNoneBlank(type) && type.equals("updatePwd")){
            for (int i = 0; i < result.size(); i++) {
                Map<String, Object> map = result.get(i);
                for (Map.Entry<String, Object> entry : map.entrySet()) {
                    User user = (User) entry.getValue();
                    if(user!=null && StringUtils.isNoneBlank(user.getId()) && StringUtils.isNoneBlank(user.getPassword())){
                        // 更新用户密码
                        userDao.updatePasswordById(user);
                        /**清除指定用户缓存**/
                        UserUtils.clearCache(user);
                        break;
                    }
                }
            }
            return "";
        }

        //删除用户时单独处理
        if(StringUtils.isNoneBlank(type) && type.equals("delete")){
            if(result != null){
                for (int i = 0; i < result.size(); i++) {
                    Map<String, Object> map = result.get(i);
                    for (Map.Entry<String, Object> entry : map.entrySet()) {
                        User user = (User) entry.getValue();
                        if(user!=null){
                            userDao.delete(user);
                            break;
                        }
                    }
                }
            }
            return "";
        }


        //处理系统管理员需要保存的数据p
        if (StringUtils.equalsIgnoreCase("1", UserUtils.getUser().getId())) {
            result = adminSaveData(result);
        }

        if (result != null) {
            //根据id查询
            List<User> users = userDao.findList(new User());
            Map<String, User> userMap = Maps.uniqueIndex(users, new Function<User, String>() {
                @Override
                public String apply(User user) {
                    return user.getId();//+(user.getOffice()==null?"":user.getOffice().getId())
                }
            });
            //如果一个人存在多个机构或者多个多部门
            List<User> uses = userDao.findList(new User());
            Map<String, User> usersMap = Maps.uniqueIndex(uses, new Function<User, String>() {
                @Override
                public String apply(User user) {
                    return user.getId() + user.getCompany().getId();
                }
            });
            for (int i = 0; i < result.size(); i++) {
                Map<String, Object> map = result.get(i);
                for (Map.Entry<String, Object> entry : map.entrySet()) {
                    User user = (User) entry.getValue();
                    if (user.getCardNo().startsWith("admin")) {
                        user.setPassword("0ab91245e701b6b170be5b4f754664421656da45238ca965b0ecbe05");
                        user.setLoginName(user.getCardNo());
                    }
                    //使用webService同步数据以及修改数据
                    if (userMap.get(user.getId()) == null) {
                        user.setDelFlag("0");
                        if (StringUtils.isBlank(user.getId())) {
                            user.preInsert();
                        }
                        if (StringUtils.isBlank(user.getPassword())) {
                            user.setPassword("0ab91245e701b6b170be5b4f754664421656da45238ca965b0ecbe05");
                        }
                        user.setLoginName(ChineseToEnglish.getFirstSpell(user.getName()));
                        userDao.insert(user);
                    } else {
                        if (usersMap.get(user.getId() + user.getCompany().getId()) == null) {
                            user.setPassword("0ab91245e701b6b170be5b4f754664421656da45238ca965b0ecbe05");
                            user.setLoginName(ChineseToEnglish.getFirstSpell(user.getName()));
                            user.preInsert();
                            userDao.insert(user);
                        } else {
                            User updateUser = userMap.get(user.getId());
                            updateUser.setOffice(user.getOffice());
                            updateUser.setLoginName(user.getLoginName());
                            updateUser.setCompany(user.getCompany());
                            updateUser.setCardNo(user.getCardNo());
                            updateUser.preUpdate();
                            userDao.update(updateUser);
                        }
                    }
                }
            }
            return "success";
        }
        return null;
    }


    /**
     * 转换，将人力资源传递的数据转成list集合
     *
     * @param json 人力资源地址,或者是AMQ传递的json数据
     * @return
     * @author yangruidong
     */
    public List<Map<String, Object>> convertList(String json) {
        Map<String, String[]> replaceMap = new HashMap<>();
        String namespace = User.class.getName();
        replaceMap.put("id", new String[]{namespace, "id"});
        replaceMap.put("name", new String[]{namespace, "name"});
        replaceMap.put("cardNo", new String[]{namespace, "cardNo"});
        replaceMap.put("orgId", new String[]{namespace, "company.id"});
        replaceMap.put("deptId", new String[]{namespace, "office.id"});
        replaceMap.put("phoneNo", new String[]{namespace, "phone"});
        replaceMap.put("email", new String[]{namespace, "email"});
        replaceMap.put("password", new String[]{namespace, "password"});//密码
        replaceMap.put("createBy", new String[]{namespace, "createBy.id"});
        replaceMap.put("createDate", new String[]{namespace, "createDate"});
        replaceMap.put("updateBy", new String[]{namespace, "updateBy.id"});
        replaceMap.put("updateDate", new String[]{namespace, "updateDate"});
        return SynchroDataUtils.getDataByJson(json, replaceMap);
    }


    /**
     * 如果是系统管理员登陆，那么只同步人力资源中的所有管理员的用户信息
     *
     * @param result 人力资源传递的数据
     * @return
     */
    public List<Map<String, Object>> adminSaveData(List<Map<String, Object>> result) {
        List<Map<String, Object>> re = new ArrayList<>();
        for (int i = 0; i < result.size(); i++) {
            Map<String, Object> map = result.get(i);
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                User user = (User) entry.getValue();
                if (user.getCardNo().startsWith("admin")) {
                    Map<String, Object> maps = new HashMap<>();
                    maps.put(entry.getKey(), user);
                    re.add(maps);
                }
            }
        }
        result = new ArrayList<>();
        result.addAll(re);
        return result;
    }

    /**
     * 根据姓名，登录名模糊查询
     * @param
     * @return
     */
    public List<User> findListByName(User user){
       return  userDao.findListByName(user);
    }
}
